home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / bash-1.12 / dist / builtins / getopts.def < prev    next >
Encoding:
Text File  |  1991-11-06  |  6.9 KB  |  273 lines
  1. This file is getopts.def, from which is created getopts.c.
  2. It implements the builtin "getopts" in Bash.
  3.  
  4. Copyright (C) 1987, 1989, 1991 Free Software Foundation, Inc.
  5.  
  6. This file is part of GNU Bash, the Bourne Again SHell.
  7.  
  8. Bash is free software; you can redistribute it and/or modify it under
  9. the terms of the GNU General Public License as published by the Free
  10. Software Foundation; either version 1, or (at your option) any later
  11. version.
  12.  
  13. Bash is distributed in the hope that it will be useful, but WITHOUT ANY
  14. WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16. for more details.
  17.  
  18. You should have received a copy of the GNU General Public License along
  19. with Bash; see the file COPYING.  If not, write to the Free Software
  20. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22. $PRODUCES getopts.c
  23.  
  24. $BUILTIN getopts
  25. $DEPENDS_ON GETOPTS_BUILTIN
  26. $FUNCTION getopts_builtin
  27. $SHORT_DOC getopts optstring name [arg]
  28.  
  29. Getopts is used by shell procedures to parse positional parameters.
  30.  
  31. OPTSTRING contains the option letters to be recognized; if a letter
  32. is followed by a colon, the option is expected to have an argument,
  33. which should be separated from it by white space.
  34.  
  35. Each time it is invoked, getopts will place the next option in the
  36. shell variable $name, initializing name if it does not exist, and
  37. the index of the next argument to be processed into the shell
  38. variable OPTIND.  OPTIND is initialized to 1 each time the shell or
  39. a shell script is invoked.  When an option requires an argument,
  40. getopts places that argument into the shell variable OPTARG.
  41.  
  42. getopts reports errors in one of two ways.  If the first character
  43. of OPTSTRING is a colon, getopts uses silent error reporting.  In
  44. this mode, no error messages are printed.  If an illegal option is
  45. seen, getopts places the option character found into OPTARG.  If a
  46. required argument is not found, getopts places a ':' into NAME and
  47. sets OPTARG to the option character found.  If getopts is not in
  48. silent mode, and an illegal option is seen, getopts places '?' into
  49. NAME and unsets OPTARG.  If a required option is not found, a '?'
  50. is placed in NAME, OPTARG is unset, and a diagnostic message is
  51. printed.
  52.  
  53. If the shell variable OPTERR has the value 0, getopts disables the
  54. printing of error messages, even if the first character of
  55. OPTSTRING is not a colon.  OPTERR has the value 1 by default.
  56.  
  57. Getopts normally parses the positional parameters ($0 - $9), but if
  58. more arguments are given, they are parsed instead.
  59. $END
  60.  
  61. #include <stdio.h>
  62. #include "../shell.h"
  63. #include "getopt.h"
  64.  
  65. #ifndef NULL
  66. #define NULL        0
  67. #endif
  68.  
  69. #define G_EOF        (-1)
  70. #define G_ILLEGAL_OPT    (-2)
  71. #define G_ARG_MISSING    (-3)
  72.  
  73. extern char *this_command_name;
  74.  
  75. /* getopts_reset is magic code for when OPTIND is reset.  N is the
  76.    value that has just been assigned to OPTIND. */
  77. void
  78. getopts_reset (newind)
  79.      int newind;
  80. {
  81.   optind = newind;
  82. }
  83.  
  84. /* Error handling is now performed as specified by Posix.2, draft 11
  85.    (identical to that of ksh-88).  The special handling is enabled if
  86.    the first character of the option string is a colon; this handling
  87.    disables diagnostic messages concerning missing option arguments
  88.    and illegal option characters.  The handling is as follows.
  89.  
  90.    ILLEGAL OPTIONS:
  91.         name -> "?"
  92.         if (special_error) then
  93.                 OPTARG = option character found
  94.                 no error output
  95.         else
  96.                 OPTARG unset
  97.                 diagnostic message
  98.         fi
  99.  
  100.   MISSING OPTION ARGUMENT;
  101.         if (special_error) then
  102.                 name -> ":"
  103.                 OPTARG = option character found
  104.         else
  105.                 name -> "?"
  106.                 OPTARG unset
  107.                 diagnostic message
  108.         fi
  109.  */
  110.  
  111. static int
  112. dogetopts (argc, argv)
  113.      int argc;
  114.      char **argv;
  115. {
  116.   int ret, special_error, old_opterr = 0;
  117.   char strval[2];
  118.   char *optstr;            /* list of options */
  119.   char *name;            /* variable to get flag val */
  120.   char *t;
  121.  
  122.   if (argc < 3)
  123.     {
  124.       builtin_error("3 arguments expected");
  125.       return (EXECUTION_FAILURE);
  126.     }
  127.  
  128.   /* argv[0] is "getopts". */
  129.  
  130.   optstr = argv[1];
  131.   name = argv[2];
  132.   argc -= 2;
  133.   argv += 2;
  134.  
  135.   special_error = optstr[0] == ':';
  136.  
  137.   if (special_error)
  138.     {
  139.       old_opterr = opterr;
  140.       optstr++;
  141.       opterr = 0;        /* suppress diagnostic messages */
  142.     }
  143.  
  144.   if (argc > 1)
  145.     {
  146.       t = argv[0];
  147.       argv[0] = dollar_vars[0];
  148.       ret = getopt(argc, argv, optstr);
  149.       argv[0] = t;
  150.     }
  151.   else
  152.     {
  153.       register int i;
  154.  
  155.       for (i = 0; dollar_vars[i]; i++);
  156.       ret = getopt (i, dollar_vars, optstr);
  157.     }
  158.  
  159.   if (special_error)
  160.     opterr = old_opterr;
  161.  
  162.   /* Set the OPTIND variable in any case, to handle "--" skipping. */
  163.   {
  164.     char numval[16];
  165.  
  166.     sprintf (numval, "%d", optind);
  167.     bind_variable ("OPTIND", numval);
  168.   }
  169.  
  170.   /* If an error occurred, decide which one it is and set the return
  171.      code appropriately.  In all cases, the option character in error
  172.      is in OPTOPT.  If an illegal option was encountered, OPTARG is
  173.      NULL.  If a required option argument was missing, OPTARG points
  174.      to a NULL string (that is, optarg[0] == 0). */
  175.   if (ret == '?')
  176.     {
  177.       if (optarg == NULL)
  178.     ret = G_ILLEGAL_OPT;
  179.       else if (optarg[0] == '\0')
  180.     ret = G_ARG_MISSING;
  181.     }
  182.         
  183.   if (ret == G_EOF)
  184.     {
  185.       bind_variable (name, "?");
  186.       return (EXECUTION_FAILURE);
  187.     }
  188.  
  189.   if (ret == G_ILLEGAL_OPT)
  190.     {
  191.       /* Illegal option encountered. */
  192.       strval[0] = '?';
  193.       strval[1] = '\0';
  194.       bind_variable (name, strval);
  195.  
  196.       if (special_error)
  197.     {
  198.       strval[0] = (char) optopt;
  199.       strval[1] = '\0';
  200.       bind_variable ("OPTARG", strval);
  201.     }
  202.       else
  203.     makunbound ("OPTARG", shell_variables);
  204.       return (EXECUTION_SUCCESS);
  205.     }
  206.  
  207.   if (ret == G_ARG_MISSING)
  208.     {
  209.       /* Required argument missing. */
  210.       if (special_error)
  211.     {
  212.       strval[0] = ':';
  213.       strval[1] = '\0';
  214.       bind_variable (name, strval);
  215.  
  216.       strval[0] = (char) optopt;
  217.       strval[1] = '\0';
  218.       bind_variable ("OPTARG", strval);
  219.     }
  220.       else
  221.     {
  222.       strval[0] = '?';
  223.       strval[1] = '\0';
  224.       bind_variable (name, strval);
  225.       makunbound ("OPTARG", shell_variables);
  226.     }
  227.       return (EXECUTION_SUCCESS);
  228.     }            
  229.  
  230.   bind_variable ("OPTARG", optarg);
  231.  
  232.   strval[0] = (char) ret;
  233.   strval[1] = '\0';
  234.   bind_variable (name, strval);
  235.  
  236.   return (EXECUTION_SUCCESS);
  237. }
  238.  
  239. /* The getopts builtin.  Build an argv, and call dogetopts with it. */
  240. int
  241. getopts_builtin (list)
  242.      WORD_LIST *list;
  243. {
  244.   register int    i;
  245.   char **av;
  246.   int ac, ret;
  247.   WORD_LIST *t = list;
  248.   static int order_set = 0;
  249.  
  250.   if (!list)
  251.     return EXECUTION_FAILURE;
  252.  
  253.   for (ac = 0; t; t = t->next, ac++);
  254.  
  255.   ac++;
  256.   av = (char **)xmalloc ((1 + ac) * sizeof (char *));
  257.   av[ac] = (char *) NULL;
  258.   av[0] = savestring (this_command_name);
  259.  
  260.   for (t = list, i = 1; t; t = t->next, i++)
  261.     av[i] = savestring (t->word->word);
  262.  
  263.   if (order_set == 0)
  264.     {
  265.       getopt_set_posix_option_order (1);
  266.       order_set++;
  267.     }
  268.  
  269.   ret = dogetopts (ac, av);
  270.   free_array (av);
  271.   return (ret);
  272. }
  273.